import axios from 'axios'
import { getSaToken } from '@/utils/auth'
// 导入oss模块中的头像上传和删除功能
import { uploadAvatar, removeAvatar } from './oss'

// 创建 axios 实例
const api = axios.create({
  baseURL: 'http://localhost:5000/auth/user', // 根据实际后端地址修改
  timeout: 15000, // 增加超时时间到15秒
  withCredentials: true, // 允许跨域携带 cookie
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 判断是否为登录或注册请求
    const isLoginRequest = config.url.includes('/doLogin');
    const isRegisterRequest = config.url.includes('/register');
    
    // 如果是登录或注册请求，不添加认证头
    if (isLoginRequest || isRegisterRequest) {
      return config;
    }
    
    // 尝试获取SaToken信息
    const saToken = getSaToken();
    
    // 检查是否有直接保存的loginId，用于辅助请求
    const savedLoginId = localStorage.getItem('loginId');
    
    if (saToken && saToken.tokenValue) {
      // 添加satoken请求头，格式为 mezhate token值
      config.headers['satoken'] = `mezhate ${saToken.tokenValue}`;
      
      // 如果saToken中没有loginId但localStorage中有，把它添加到请求头中
      if (!saToken.loginId && savedLoginId) {
        console.log('使用localStorage中的loginId:', savedLoginId);
        config.headers['loginId'] = savedLoginId;
      } else if (saToken.loginId) {
        // 使用saToken中的loginId
        config.headers['loginId'] = saToken.loginId;
      }
    } else {
      // 如果没有token值，使用固定格式
      const token = localStorage.getItem('token');
      if (token) {
        config.headers['satoken'] = `mezhate ${token}`;
        
        // 如果有savedLoginId，也添加到请求头
        if (savedLoginId) {
          config.headers['loginId'] = savedLoginId;
        }
      } else {
        // 即使没有token，也添加satoken头，值为固定格式
        config.headers['satoken'] = `mezhate token`;
      }
    }
    
    // 添加待处理的用户名到请求头，以防loginId不可用
    const pendingLoginId = localStorage.getItem('pendingLoginId');
    if (pendingLoginId && !config.headers['loginId']) {
      console.log('使用pendingLoginId:', pendingLoginId);
      config.headers['userName'] = pendingLoginId;
    }
    
    return config;
  },
  error => {
    return Promise.reject(error);
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    return response.data
  },
  error => {
    if (error.code === 'ECONNABORTED') {
      return Promise.reject(new Error('请求超时，请检查网络连接'))
    }
    if (error.response) {
      switch (error.response.status) {
        case 401:
          // 未授权，清除token并跳转到登录页
          localStorage.removeItem('token')
          localStorage.removeItem('saTokenInfo')
          
          // 触发登出事件
          if (window.Vue && window.Vue.prototype && window.Vue.prototype.$root) {
            window.Vue.prototype.$root.$emit('logout')
          }
          
          window.location.href = '/login'
          return Promise.reject(new Error('登录已过期，请重新登录'))
        case 403:
          return Promise.reject(new Error('没有权限访问'))
        case 404:
          return Promise.reject(new Error('请求的资源不存在'))
        case 500:
          return Promise.reject(new Error('服务器错误'))
        default:
          return Promise.reject(new Error(error.response.data?.message || '请求失败'))
      }
    } else if (error.request) {
      return Promise.reject(new Error('网络错误，请检查网络连接'))
    } else {
      return Promise.reject(new Error('请求配置错误'))
    }
  }
)

// 登录
export const login = (data) => {
  return api.post('/doLogin', data);
}

// 注册
export const register = (data) => {
  return api.post('/register', data)
}

// 登出
export const logout = (userName) => {
  // 严格检查userName，确保它是一个有效的字符串
  if (!userName || typeof userName !== 'string' || userName.trim() === '') {
    return Promise.reject(new Error('用户名无效，无法登出'));
  }
  
  // 对userName进行URL编码以处理特殊字符
  const encodedUserName = encodeURIComponent(userName.trim());
  
  // 构建带查询参数的URL
  const url = `/logOut?userName=${encodedUserName}`;
  
  // 使用GET请求，参数通过URL查询字符串发送
  // 创建完整配置对象确保请求正确处理
  return api.request({
    url: url,
    method: 'GET',
    headers: {
      // 确保headers与拦截器一致
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    }
  })
  .then(response => {
    return response;
  })
  .catch(error => {
    throw error;
  });
}

// 获取用户信息
export const getUserInfo = (userName) => {
  // 确保userName已定义
  if (!userName) {
    return Promise.reject(new Error('获取用户信息失败: 未提供用户名'));
  }
  
  // 创建请求体，JSON格式
  const requestBody = {
    userName: userName
  };
  
  // 使用POST方法发送请求，确保使用JSON格式
  return api.request({
    url: '/info',
    method: 'POST',
    data: requestBody,
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
      'satoken': 'mezhate token'
    }
  });
}

// 获取当前登录用户的详细信息
export const getCurrentUserInfo = (userName, forceRefresh = true) => {
  // 如果强制刷新，则跳过缓存检查
  if (!forceRefresh) {
    // 检查本地缓存，如果有且未过期则直接返回
    const cachedUserInfo = localStorage.getItem('cachedUserInfo');
    const cacheTimestamp = localStorage.getItem('userInfoCacheTimestamp');
    
    // 如果有缓存且未过期（缓存有效期为30分钟）
    if (cachedUserInfo && cacheTimestamp) {
      const cacheTime = parseInt(cacheTimestamp);
      const currentTime = new Date().getTime();
      const cacheAge = currentTime - cacheTime;
      
      // 如果缓存未过期（30分钟内）
      if (cacheAge < 30 * 60 * 1000) {
        return Promise.resolve(JSON.parse(cachedUserInfo));
      }
    }
  }
  
  // 确保userName已定义
  if (!userName) {
    return Promise.reject(new Error('获取用户信息失败: 未提供用户名'));
  }
  
  // 创建与后端期望的AuthUserDTO结构匹配的请求体
  const requestBody = {
    userName: userName,
    // 可能需要的其他字段设为null或默认值
    id: null,
    password: null,
    nickName: null,
    email: null,
    phone: null,
    avatar: null
  };
  
  // 使用正确的端点地址
  return api.post('/getUserInfo', requestBody)
    .then(response => {
      // 检查响应是否有效
      if (response.success && response.data) {
        // 检查是否有模拟头像存储
        const storedAvatar = localStorage.getItem(`avatar_${userName}`);
        if (storedAvatar && (!response.data.avatar || forceRefresh)) {
          // 如果有模拟头像且API返回的头像为空或强制刷新，使用本地存储的头像
          console.log('使用本地存储的模拟头像:', storedAvatar);
          response.data.avatar = storedAvatar;
        }
      }
      
      // 只有在非强制刷新模式下才缓存响应
      if (response.success && response.data && !forceRefresh) {
        localStorage.setItem('cachedUserInfo', JSON.stringify(response));
        localStorage.setItem('userInfoCacheTimestamp', new Date().getTime().toString());
      }
      
      return response;
    })
    .catch(error => {
      throw error;
    });
}

// 清除用户信息缓存
export const clearUserInfoCache = () => {
  localStorage.removeItem('cachedUserInfo');
  localStorage.removeItem('userInfoCacheTimestamp');
}

// 更新用户信息
export const updateUserInfo = (userData) => {
  // 更新用户信息后清除缓存，确保下次获取是最新数据
  clearUserInfoCache();
  return api.post('/update', userData);
}

// 更新密码
export const updatePassword = (currentPassword, newPassword) => {
  const requestBody = {
    currentPassword,
    newPassword
  };
  return api.post('/updatePassword', requestBody);
}

// 更新通知设置
export const updateNotificationSettings = (notificationSettings) => {
  // 这个API接口可能还没实现，可以暂时用模拟数据
  return Promise.resolve({
    success: true,
    message: '通知设置已更新',
    data: notificationSettings
  });
  
  // 实际实现应该是：
  // return api.post('/updateNotificationSettings', notificationSettings);
}

// 更新隐私设置
export const updatePrivacySettings = (privacySettings) => {
  // 这个API接口可能还没实现，可以暂时用模拟数据
  return Promise.resolve({
    success: true,
    message: '隐私设置已更新',
    data: privacySettings
  });
  
  // 实际实现应该是：
  // return api.post('/updatePrivacySettings', privacySettings);
}

// 检查登录状态
export const checkLoginStatus = () => {
  console.log('检查登录状态...');
  return api.get('/status').then(response => {
    console.log('登录状态响应:', response);
    
    // 如果响应成功且包含用户信息
    if (response.success && response.data) {
      // 如果响应中包含loginId字段
      if (response.data.loginId) {
        console.log('从后端获取到loginId:', response.data.loginId);
        
        // 获取当前保存的saTokenInfo
        const saTokenInfo = JSON.parse(localStorage.getItem('saTokenInfo') || '{}');
        
        // 使用响应中的loginId更新saTokenInfo
        saTokenInfo.loginId = response.data.loginId;
        
        // 保存更新后的saTokenInfo
        localStorage.setItem('saTokenInfo', JSON.stringify(saTokenInfo));
        
        // 同时单独保存loginId方便访问
        localStorage.setItem('loginId', response.data.loginId);
      } else {
        console.log('后端响应中没有loginId字段');
      }
    } else {
      console.log('检查登录状态失败或未登录');
    }
    
    return response;
  }).catch(error => {
    console.error('检查登录状态出错:', error);
    throw error;
  });
}

// 重新导出从oss.js导入的方法
export { uploadAvatar, removeAvatar }

/**
 * 获取排行榜数据 - 根据积分高低排序用户信息
 * @param {Object} params - 查询参数
 * @param {number} params.pageNo - 页码，默认为1
 * @param {number} params.pageSize - 每页条数，默认为10
 * @returns {Promise} - 返回Promise对象，包含JSON格式的排行榜数据
 */
export const getLeaderboard = (params = {}) => {
  // 设置默认参数，只使用AuthUserDTO支持的字段
  const defaultParams = {
    pageNo: 1,
    pageSize: 10,
    ...params
  };
  
  // 使用POST方法发送请求
  return api.request({
    url: '/getLeaderboard',
    method: 'POST',
    data: defaultParams,
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
      'satoken': 'mezhate token'
    }
  });
}

// 获取用户列表（用于管理员页面）
export const getUserList = (params = {}) => {
  // 创建默认分页参数
  const defaultParams = {
    pageNo: 1,
    pageSize: 20,
    ...params
  };
  
  return api.post('/getUserList', defaultParams);
} 